{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1887d7f8",
   "metadata": {},
   "source": [
    "# FastHTML By Example\n",
    "\n",
    "> An introduction to FastHTML from the ground up, with four complete examples\n",
    "\n",
    "- order: 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aba95bb",
   "metadata": {},
   "source": [
    "This tutorial provides an alternate introduction to FastHTML by building out example applications. We also illustrate how to use FastHTML foundations to create custom web apps. Finally, this document serves as minimal context for a LLM to turn it into a FastHTML assistant.\n",
    "\n",
    "Let's get started."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7aa21cce",
   "metadata": {},
   "source": [
    "## FastHTML Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca0a9e67",
   "metadata": {},
   "source": [
    "FastHTML is *just Python*. You can install it with `pip install python-fasthtml`. Extensions/components built for it can likewise be distributed via PyPI or as simple Python files.\n",
    "\n",
    "The core usage of FastHTML is to define routes, and then to define what to do at each route. This is similar to the [FastAPI](https://fastapi.tiangolo.com/) web framework (in fact we implemented much of the functionality to match the FastAPI usage examples), but where FastAPI focuses on returning JSON data to build APIs, FastHTML focuses on returning HTML data.\n",
    "\n",
    "Here's a simple FastHTML app that returns a \"Hello, World\" message:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1c09ea5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from fasthtml.common import FastHTML, serve\n",
    "\n",
    "app = FastHTML()\n",
    "\n",
    "@app.get(\"/\")\n",
    "def home():\n",
    "    return \"<h1>Hello, World</h1>\"\n",
    "\n",
    "serve()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c85e864e",
   "metadata": {},
   "source": [
    "To run this app, place it in a file, say `app.py`, and then run it with `python app.py`.\n",
    "\n",
    "```\n",
    "INFO:     Will watch for changes in these directories: ['/home/jonathan/fasthtml-example']\n",
    "INFO:     Uvicorn running on http://127.0.0.1:5001 (Press CTRL+C to quit)\n",
    "INFO:     Started reloader process [871942] using WatchFiles\n",
    "INFO:     Started server process [871945]\n",
    "INFO:     Waiting for application startup.\n",
    "INFO:     Application startup complete.\n",
    "```\n",
    "\n",
    "If you navigate to [http://127.0.0.1:5001](http://127.0.0.1:5001) in a browser, you'll see your \"Hello, World\". If you edit the `app.py` file and save it, the server will reload and you'll see the updated message when you refresh the page in your browser."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b6c4f67",
   "metadata": {},
   "source": [
    "## Constructing HTML"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f0238a8",
   "metadata": {},
   "source": [
    "Notice we wrote some HTML in the previous example. We don't want to do that! Some web frameworks require that you learn HTML, CSS, JavaScript AND some templating language AND python. We want to do as much as possible with just one language. Fortunately, the Python module [fastcore.xml](https://fastcore.fast.ai/xml.html) has all we need for constructing HTML from Python, and FastHTML includes all the tags you need to get started. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d26ff2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<!doctype html></!doctype>\n",
      "\n",
      "<html>\n",
      "  <head>\n",
      "    <title>Some page</title>\n",
      "  </head>\n",
      "  <body>\n",
      "    <div class=\"myclass\">\n",
      "Some text, \n",
      "      <a href=\"https://example.com\">A link</a>\n",
      "      <img src=\"https://placehold.co/200\">\n",
      "    </div>\n",
      "  </body>\n",
      "</html>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from fasthtml.common import *\n",
    "page = Html(\n",
    "    Head(Title('Some page')),\n",
    "    Body(Div('Some text, ', A('A link', href='https://example.com'), Img(src=\"https://placehold.co/200\"), cls='myclass')))\n",
    "print(to_xml(page))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37c46876",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!doctype html></!doctype>\n",
       "\n",
       "<html>\n",
       "  <head>\n",
       "    <title>Some page</title>\n",
       "  </head>\n",
       "  <body>\n",
       "    <div class=\"myclass\">\n",
       "Some text, \n",
       "      <a href=\"https://example.com\">A link</a>\n",
       "      <img src=\"https://placehold.co/200\">\n",
       "    </div>\n",
       "  </body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show(page)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5236a3f7",
   "metadata": {},
   "source": [
    "If that `import *` worries you, you can always import only the tags you need. \n",
    "\n",
    "FastHTML is smart enough to know about fastcore.xml, and so you don't need to use the `to_xml` function to convert your FT objects to HTML. You can just return them as you would any other Python object. For example, if we modify our previous example to use fastcore.xml, we can return an FT object directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6e4a21d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from fasthtml.common import *\n",
    "app = FastHTML()\n",
    "\n",
    "@app.get(\"/\")\n",
    "def home():\n",
    "    page = Html(\n",
    "        Head(Title('Some page')),\n",
    "        Body(Div('Some text, ', A('A link', href='https://example.com'), Img(src=\"https://placehold.co/200\"), cls='myclass')))\n",
    "    return page\n",
    "\n",
    "serve()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e968c90",
   "metadata": {},
   "source": [
    "This will render the HTML in the browser.\n",
    "\n",
    "For debugging, you can right-click on the rendered HTML in the browser and select \"Inspect\" to see the underlying HTML that was generated. There you'll also find the 'network' tab, which shows you the requests that were made to render the page. Refresh and look for the request to `127.0.0.1` - and you'll see it's just a `GET` request to `/`, and the response body is the HTML you just returned.\n",
    "\n",
    ":::{.callout-tip}\n",
    "# Live Reloading\n",
    "You can also enable [live reloading](../ref/live_reload.ipynb) so you don't have to manually refresh your browser to view updates.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca921e6a",
   "metadata": {},
   "source": [
    "You can also use Starlette's `TestClient` to try it out in a notebook: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fc09099",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<html>\n",
      "  <head><title>Some page</title>\n",
      "</head>\n",
      "  <body><div class=\"myclass\">\n",
      "Some text, \n",
      "  <a href=\"https://example.com\">A link</a>\n",
      "  <img src=\"https://placehold.co/200\">\n",
      "</div>\n",
      "</body>\n",
      "</html>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from starlette.testclient import TestClient\n",
    "client = TestClient(app)\n",
    "r = client.get(\"/\")\n",
    "print(r.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91321eaf",
   "metadata": {},
   "source": [
    "FastHTML wraps things in an Html tag if you don't do it yourself (unless the request comes from htmx, in which case you get the element directly). \n",
    "See [FT objects and HTML](#ft-objects-and-html) for more on creating custom components or adding HTML rendering to existing Python objects.\n",
    "To give the page a non-default title, return a Title before your main content:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "349d07f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<!doctype html></!doctype>\n",
      "\n",
      "<html>\n",
      "  <head>\n",
      "    <title>Page Demo</title>\n",
      "    <meta charset=\"utf-8\"></meta>\n",
      "    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1, viewport-fit=cover\"></meta>\n",
      "    <script src=\"https://unpkg.com/htmx.org@next/dist/htmx.min.js\"></script>\n",
      "    <script src=\"https://cdn.jsdelivr.net/gh/answerdotai/surreal@1.3.0/surreal.js\"></script>\n",
      "    <script src=\"https://cdn.jsdelivr.net/gh/gnat/css-scope-inline@main/script.js\"></script>\n",
      "  </head>\n",
      "  <body>\n",
      "<div>\n",
      "  <h1>Hello, World</h1>\n",
      "  <p>Some text</p>\n",
      "  <p>Some more text</p>\n",
      "</div>\n",
      "  </body>\n",
      "</html>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "app = FastHTML()\n",
    "\n",
    "@app.get(\"/\")\n",
    "def home():\n",
    "    return Title(\"Page Demo\"), Div(H1('Hello, World'), P('Some text'), P('Some more text'))\n",
    "\n",
    "client = TestClient(app)\n",
    "print(client.get(\"/\").text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "977e4cee",
   "metadata": {},
   "source": [
    "We'll use this pattern often in the examples to follow."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2e8ad3b",
   "metadata": {},
   "source": [
    "## Defining Routes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11a04e8b",
   "metadata": {},
   "source": [
    "\n",
    "The HTTP protocol defines a number of methods ('verbs') to send requests to a server. The most common are GET, POST, PUT, DELETE, and HEAD. We saw 'GET' in action before - when you navigate to a URL, you're making a GET request to that URL. We can do different things on a route for different HTTP methods. For example:\n",
    "\n",
    "```python\n",
    "@app.route(\"/\", methods='get')\n",
    "def home():\n",
    "    return H1('Hello, World')\n",
    "\n",
    "@app.route(\"/\", methods=['post', 'put'])\n",
    "def post_or_put():\n",
    "    return \"got a POST or PUT request\"\n",
    "```\n",
    "\n",
    "This says that when someone navigates to the root URL \"/\" (i.e. sends a GET request), they will see the big \"Hello, World\" heading. When someone submits a POST or PUT request to the same URL, the server should return the string \"got a post or put request\".\n",
    "\n",
    ":::{.callout-tip}\n",
    "## Test the POST request\n",
    "\n",
    "You can test the POST request with `curl -X POST http://127.0.0.1:8000 -d \"some data\"`. This sends some data to the server, you should see the response \"got a post or put request\" printed in the terminal.\n",
    ":::\n",
    "\n",
    "There are a few other ways you can specify the route+method - FastHTML has `.get`, `.post`, etc. as shorthand for `route(..., methods=['get'])`, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82ba7a56",
   "metadata": {},
   "outputs": [],
   "source": [
    "@app.get(\"/\")\n",
    "def my_function():\n",
    "    return \"Hello World from a GET request\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2eb2f24e",
   "metadata": {},
   "source": [
    " Or you can use the `@rt` decorator without a method but specify the method with the name of the function. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1ce4212",
   "metadata": {},
   "outputs": [],
   "source": [
    "rt = app.route\n",
    "\n",
    "@rt(\"/\")\n",
    "def post():\n",
    "    return \"Hello World from a POST request\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e844c387",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World from a POST request'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.post(\"/\").text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2c0549d",
   "metadata": {},
   "source": [
    "You're welcome to pick whichever style you prefer. Using routes lets you show different content on different pages - '/home', '/about' and so on. You can also respond differently to different kinds of requests to the same route, as shown above. You can also pass data via the route:\n",
    "\n",
    ":::{.panel-tabset}\n",
    "\n",
    "## `@app.get`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "896e2757",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Good day to you, Dave!'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@app.get(\"/greet/{nm}\")\n",
    "def greet(nm:str):\n",
    "    return f\"Good day to you, {nm}!\"\n",
    "\n",
    "client.get(\"/greet/Dave\").text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b213d38",
   "metadata": {},
   "source": [
    "## `@rt`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d05a950d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Good day to you, Dave!'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@rt(\"/greet/{nm}\")\n",
    "def get(nm:str):\n",
    "    return f\"Good day to you, {nm}!\"\n",
    "\n",
    "client.get(\"/greet/Dave\").text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cda0b0f",
   "metadata": {},
   "source": [
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31183d7b",
   "metadata": {},
   "source": [
    "More on this in the [More on Routing and Request Parameters](#more-on-routing-and-request-parameters) section, which goes deeper into the different ways to get information from a request."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f99dde3c",
   "metadata": {},
   "source": [
    "## Styling Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b53a6f26",
   "metadata": {},
   "source": [
    "Plain HTML probably isn't quite what you imagine when you visualize your beautiful web app. CSS is the go-to language for styling HTML. But again, we don't want to learn extra languages unless we absolutely have to! Fortunately, there are ways to get much more visually appealing sites by relying on the hard work of others, using existing CSS libraries. One of our favourites is [PicoCSS](https://picocss.com/). A common way to add CSS files to web pages is to use a [`<link>`](https://www.w3schools.com/tags/tag_link.asp) tag inside your [HTML header](https://www.w3schools.com/tags/tag_header.asp), like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2820bdac",
   "metadata": {},
   "source": [
    "```html\n",
    "<header>\n",
    "    ...\n",
    "    <link rel=\"stylesheet\" href=\"https://cdn.jsdelivr.net/npm/@picocss/pico@latest/css/pico.min.css\">\n",
    "</header>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f62b488",
   "metadata": {},
   "source": [
    "For convenience, FastHTML already defines a Pico component for you with `picolink`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60eb0b84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<link rel=\"stylesheet\" href=\"https://cdn.jsdelivr.net/npm/@picocss/pico@latest/css/pico.min.css\">\n",
      "\n",
      "<style>:root { --pico-font-size: 100%; }</style>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(to_xml(picolink))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfd3e30f",
   "metadata": {},
   "source": [
    ":::{.callout-note}\n",
    "`picolink` also includes a `<style>` tag, as we found that setting the font-size to 100% to be a good default.  We show you how to override this below.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "413be2ce",
   "metadata": {},
   "source": [
    "Since we typically want CSS styling on all pages of our app, FastHTML lets you define a shared HTML header with the `hdrs` argument as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7617a977",
   "metadata": {},
   "outputs": [],
   "source": [
    "from fasthtml.common import *\n",
    "css = Style(':root {--pico-font-size:90%,--pico-font-family: Pacifico, cursive;}') # <1>\n",
    "app = FastHTML(hdrs=(picolink, css)) # <2>\n",
    "\n",
    "@app.route(\"/\")\n",
    "def get():\n",
    "    return (Title(\"Hello World\"), \n",
    "            Main(H1('Hello, World'), cls=\"container\")) # <3>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "893931a6",
   "metadata": {},
   "source": [
    "1. Custom styling to override the pico defaults\n",
    "2. Define shared headers for all pages\n",
    "3. As per the [pico docs](https://picocss.com/docs), we put all of our content inside a `<main>` tag with a class of `container`:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e169b563",
   "metadata": {},
   "source": [
    ":::{.callout-note}\n",
    "\n",
    "## Returning Tuples\n",
    "\n",
    "We're returning a tuple here (a title and the main page). Returning a tuple, list, `FT` object, or an object with a `__ft__` method tells FastHTML to turn the main body into a full HTML page that includes the headers (including the pico link and our custom css) which we passed in. This only occurs if the request isn't from HTMX (for HTMX requests we need only return the rendered components).\n",
    "\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0dcb5f5",
   "metadata": {},
   "source": [
    "You can check out the Pico [examples](https://picocss.com/examples) page to see how different elements will look. If everything is working, the page should now render nice text with our custom font, and it should respect the user's light/dark mode preferences too."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86e54428",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "If you want to [override the default styles](https://picocss.com/docs/css-variables) or add more custom CSS, you can do so by adding a `<style>` tag to the headers as shown above. So you are allowed to write CSS to your heart's content - we just want to make sure you don't necessarily have to! Later on we'll see examples using other component libraries and tailwind css to do more fancy styling things, along with tips to get an LLM to write all those fiddly bits so you don't have to."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d9e7d15",
   "metadata": {},
   "source": [
    "## Web Page -> Web App"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c064d9e",
   "metadata": {},
   "source": [
    "Showing content is all well and good, but we typically expect a bit more *interactivity* from something calling itself a web app! So, let's add a few different pages, and use a form to let users add messages to a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "929dc435",
   "metadata": {},
   "outputs": [],
   "source": [
    "app = FastHTML()\n",
    "messages = [\"This is a message, which will get rendered as a paragraph\"]\n",
    "\n",
    "@app.get(\"/\")\n",
    "def home():\n",
    "    return Main(H1('Messages'), \n",
    "                *[P(msg) for msg in messages],\n",
    "                A(\"Link to Page 2 (to add messages)\", href=\"/page2\"))\n",
    "\n",
    "@app.get(\"/page2\")\n",
    "def page2():\n",
    "    return Main(P(\"Add a message with the form below:\"),\n",
    "                Form(Input(type=\"text\", name=\"data\"),\n",
    "                     Button(\"Submit\"),\n",
    "                     action=\"/\", method=\"post\"))\n",
    "\n",
    "@app.post(\"/\")\n",
    "def add_message(data:str):\n",
    "    messages.append(data)\n",
    "    return home()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bc9da86",
   "metadata": {},
   "source": [
    "We re-render the entire homepage to show the newly added message. This is fine, but modern web apps often don't re-render the entire page, they just update a part of the page. In fact even very complicated applications are often implemented as 'Single Page Apps' (SPAs). This is where HTMX comes in."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e7066db",
   "metadata": {},
   "source": [
    "## HTMX"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fca91962",
   "metadata": {},
   "source": [
    "[HTMX](https://htmx.org/) addresses some key limitations of HTML. In vanilla HTML, links can trigger a GET request to show a new page, and forms can send requests containing data to the server. A lot of 'Web 1.0' design revolved around ways to use these to do everything we wanted. But why should only *some* elements be allowed to trigger requests? And why should we refresh the *entire page* with the result each time one does? HTMX extends HTML to allow us to trigger requests from *any* element on all kinds of events, and to update a part of the page without refreshing the entire page. It's a powerful tool for building modern web apps.\n",
    "\n",
    "It does this by adding attributes to HTML tags to make them do things. For example, here's a page with a counter and a button that increments it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3420d621",
   "metadata": {},
   "outputs": [],
   "source": [
    "app = FastHTML()\n",
    "\n",
    "count = 0\n",
    "\n",
    "@app.get(\"/\")\n",
    "def home():\n",
    "    return Title(\"Count Demo\"), Main(\n",
    "        H1(\"Count Demo\"),\n",
    "        P(f\"Count is set to {count}\", id=\"count\"),\n",
    "        Button(\"Increment\", hx_post=\"/increment\", hx_target=\"#count\", hx_swap=\"innerHTML\")\n",
    "    )\n",
    "\n",
    "@app.post(\"/increment\")\n",
    "def increment():\n",
    "    print(\"incrementing\")\n",
    "    global count\n",
    "    count += 1\n",
    "    return f\"Count is set to {count}\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fad30d3",
   "metadata": {},
   "source": [
    "The button triggers a POST request to `/increment` (since we set `hx_post=\"/increment\"`), which increments the count and returns the new count. The `hx_target` attribute tells HTMX where to put the result. If no target is specified it replaces the element that triggered the request. The `hx_swap` attribute specifies how it adds the result to the page. Useful options are:\n",
    "\n",
    "- *`innerHTML`*: Replace the target element's content with the result.\n",
    "- *`outerHTML`*: Replace the target element with the result.\n",
    "- *`beforebegin`*: Insert the result before the target element.\n",
    "- *`beforeend`*: Insert the result inside the target element, after its last child.\n",
    "- *`afterbegin`*: Insert the result inside the target element, before its first child.\n",
    "- *`afterend`*: Insert the result after the target element.\n",
    "\n",
    "You can also use an hx_swap of `delete` to delete the target element regardless of response, or of `none` to do nothing.\n",
    "\n",
    "By default, requests are triggered by the “natural” event of an element - click in the case of a button (and most other elements). You can also specify different triggers, along with various modifiers - see the [HTMX docs](https://htmx.org/docs/#triggers) for more.\n",
    "\n",
    "This pattern of having elements trigger requests that modify or replace other elements is a key part of the HTMX philosophy. It takes a little getting used to, but once mastered it is extremely powerful.\n",
    "\n",
    "### Replacing Elements Besides the Target\n",
    "\n",
    "Sometimes having a single target is not enough, and we'd like to specify some additional elements to update or remove. In these cases, returning elements with an id that matches the element to be replaced and `hx_swap_oob='true'` will replace those elements too. We'll use this in the next example to clear an input field when we submit a form."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a7e887f",
   "metadata": {},
   "source": [
    "## Full Example #1 - ToDo App"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "075feaca",
   "metadata": {},
   "source": [
    "The canonical demo web app! A TODO list. Rather than create yet another variant for this tutorial, we recommend starting with this video tutorial from Jeremy:\n",
    "\n",
    "{{< video https://www.youtube.com/embed/Auqrm7WFc0I >}}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ad3ea49",
   "metadata": {},
   "source": [
    "We've made a number of variants of this app - so in addition to the version shown in the video you can browse [this](https://github.com/AnswerDotAI/fasthtml-tut) series of examples with increasing complexity, the heavily-commented [\"idiomatic\" version here](https://github.com/AnswerDotAI/fasthtml/blob/main/examples/adv_app.py), and the [example](https://github.com/AnswerDotAI/fasthtml-example/tree/main/01_todo_app) linked from the [FastHTML homepage](https://fastht.ml/)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b63a4a8",
   "metadata": {},
   "source": [
    "## Full Example #2 - Image Generation App"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68948455",
   "metadata": {},
   "source": [
    "Let's create an image generation app. We'd like to wrap a text-to-image model in a nice UI, where the user can type in a prompt and see a generated image appear. We'll use a model hosted by [Replicate](https://replicate.com) to actually generate the images. Let's start with the homepage, with a form to submit prompts and a div to hold the generated images:\n",
    "\n",
    "```python\n",
    "# Main page\n",
    "@app.get(\"/\")\n",
    "def get():\n",
    "    inp = Input(id=\"new-prompt\", name=\"prompt\", placeholder=\"Enter a prompt\")\n",
    "    add = Form(Group(inp, Button(\"Generate\")), hx_post=\"/\", target_id='gen-list', hx_swap=\"afterbegin\")\n",
    "    gen_list = Div(id='gen-list')\n",
    "    return Title('Image Generation Demo'), Main(H1('Magic Image Generation'), add, gen_list, cls='container')\n",
    "```\n",
    "\n",
    "Submitting the form will trigger a POST request to `/`, so next we need to generate an image and add it to the list. One problem: generating images is slow! We'll start the generation in a separate thread, but this now surfaces a different problem: we want to update the UI right away, but our image will only be ready a few seconds later. This is a common pattern - think about how often you see a loading spinner online. We need a way to return a temporary bit of UI which will eventually be replaced by the final image. Here's how we might do this:\n",
    "\n",
    "```python\n",
    "def generation_preview(id):\n",
    "    if os.path.exists(f\"gens/{id}.png\"):\n",
    "        return Div(Img(src=f\"/gens/{id}.png\"), id=f'gen-{id}')\n",
    "    else:\n",
    "        return Div(\"Generating...\", id=f'gen-{id}', \n",
    "                   hx_post=f\"/generations/{id}\",\n",
    "                   hx_trigger='every 1s', hx_swap='outerHTML')\n",
    "    \n",
    "@app.post(\"/generations/{id}\")\n",
    "def get(id:int): return generation_preview(id)\n",
    "\n",
    "@app.post(\"/\")\n",
    "def post(prompt:str):\n",
    "    id = len(generations)\n",
    "    generate_and_save(prompt, id)\n",
    "    generations.append(prompt)\n",
    "    clear_input =  Input(id=\"new-prompt\", name=\"prompt\", placeholder=\"Enter a prompt\", hx_swap_oob='true')\n",
    "    return generation_preview(id), clear_input\n",
    "\n",
    "@threaded\n",
    "def generate_and_save(prompt, id): ... \n",
    "```\n",
    "\n",
    "The form sends the prompt to the `/` route, which starts the generation in a separate thread then returns two things:\n",
    "\n",
    "- A generation preview element that will be added to the top of the `gen-list` div (since that is the target_id of the form which triggered the request)\n",
    "- An input field that will replace the form's input field (that has the same id), using the hx_swap_oob='true' trick. This clears the prompt field so the user can type another prompt.\n",
    "\n",
    "The generation preview first returns a temporary \"Generating...\" message, which polls the `/generations/{id}` route every second. This is done by setting hx_post to the route and hx_trigger to 'every 1s'. The `/generations/{id}` route returns the preview element every second until the image is ready, at which point it returns the final image. Since the final image replaces the temporary one (hx_swap='outerHTML'), the polling stops running and the generation preview is now complete.\n",
    "\n",
    "This works nicely - the user can submit several prompts without having to wait for the first one to generate, and as the images become available they are added to the list. You can see the full code of this version [here](https://github.com/AnswerDotAI/fasthtml-example/blob/main/image_app_simple/draft1.py)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98c39050",
   "metadata": {},
   "source": [
    "\n",
    "### Again, with Style\n",
    "\n",
    "The app is functional, but can be improved. The [next version](https://github.com/AnswerDotAI/fasthtml-example/blob/main/image_app_simple/main.py) adds more stylish generation previews, lays out the images in a grid layout that is responsive to different screen sizes, and adds a database to track generations and make them persistent. The database part is very similar to the todo list example, so let's just quickly look at how we add the nice grid layout. This is what the result looks like:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d53f0e65",
   "metadata": {},
   "source": [
    "![image.png](https://github.com/AnswerDotAI/fasthtml-example/blob/main/image_app_simple/screenshot.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df72587f",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Step one was looking around for existing components. The Pico CSS library we've been using has a rudimentary grid but recommends using an alternative layout system. One of the options listed was [Flexbox](http://flexboxgrid.com/). \n",
    "\n",
    "To use Flexbox you create a \"row\" with one or more elements. You can specify how wide things should be with a specific syntax in the class name. For example, `col-xs-12` means a box that will take up 12 columns (out of 12 total) of the row on extra small screens, `col-sm-6` means a column that will take up 6 columns of the row on small screens, and so on. So if you want four columns on large screens you would use `col-lg-3` for each item (i.e. each item is using 3 columns out of 12). \n",
    "\n",
    "```html\n",
    "<div class=\"row\">\n",
    "    <div class=\"col-xs-12\">\n",
    "        <div class=\"box\">This takes up the full width</div>\n",
    "    </div>\n",
    "</div>\n",
    "```\n",
    "\n",
    "This was non-intuitive to me. Thankfully ChatGPT et al know web stuff quite well, and we can also experiment in a notebook to test things out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc5db969",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!doctype html></!doctype>\n",
       "\n",
       "<html>\n",
       "  <link rel=\"stylesheet\" href=\"https://cdnjs.cloudflare.com/ajax/libs/flexboxgrid/6.3.1/flexboxgrid.min.css\" type=\"text/css\">\n",
       "  <div class=\"row\" style=\"color: #fff;\">\n",
       "    <div class=\"col-xs-12\">\n",
       "      <div class=\"box\" style=\"background-color: #800000;\">This takes up the full width</div>\n",
       "    </div>\n",
       "    <div class=\"col-xs-6\">\n",
       "      <div class=\"box\" style=\"background-color: #008000;\">This takes up half</div>\n",
       "    </div>\n",
       "    <div class=\"col-xs-6\">\n",
       "      <div class=\"box\" style=\"background-color: #0000B0;\">This takes up half</div>\n",
       "    </div>\n",
       "  </div>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid = Html(\n",
    "    Link(rel=\"stylesheet\", href=\"https://cdnjs.cloudflare.com/ajax/libs/flexboxgrid/6.3.1/flexboxgrid.min.css\", type=\"text/css\"),\n",
    "    Div(\n",
    "        Div(Div(\"This takes up the full width\", cls=\"box\", style=\"background-color: #800000;\"), cls=\"col-xs-12\"),\n",
    "        Div(Div(\"This takes up half\", cls=\"box\", style=\"background-color: #008000;\"), cls=\"col-xs-6\"),\n",
    "        Div(Div(\"This takes up half\", cls=\"box\", style=\"background-color: #0000B0;\"), cls=\"col-xs-6\"),\n",
    "        cls=\"row\", style=\"color: #fff;\"\n",
    "    )\n",
    ")\n",
    "show(grid)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a6f3895",
   "metadata": {},
   "source": [
    "Aside: when in doubt with CSS stuff, add a background color or a border so you can see what's happening!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "531d6057",
   "metadata": {},
   "source": [
    "Translating this into our app, we have a new homepage with a `div (class=\"row\")` to store the generated images / previews, and a `generation_preview` function that returns boxes with the appropriate classes and styles to make them appear in the grid. I chose a layout with different numbers of columns for different screen sizes, but you could also *just* specify the `col-xs` class if you wanted the same layout on all devices."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6de14a3b",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "```python\n",
    "gridlink = Link(rel=\"stylesheet\", href=\"https://cdnjs.cloudflare.com/ajax/libs/flexboxgrid/6.3.1/flexboxgrid.min.css\", type=\"text/css\")\n",
    "app = FastHTML(hdrs=(picolink, gridlink))\n",
    "\n",
    "# Main page\n",
    "@app.get(\"/\")\n",
    "def get():\n",
    "    inp = Input(id=\"new-prompt\", name=\"prompt\", placeholder=\"Enter a prompt\")\n",
    "    add = Form(Group(inp, Button(\"Generate\")), hx_post=\"/\", target_id='gen-list', hx_swap=\"afterbegin\")\n",
    "    gen_containers = [generation_preview(g) for g in gens(limit=10)] # Start with last 10\n",
    "    gen_list = Div(*gen_containers[::-1], id='gen-list', cls=\"row\") # flexbox container: class = row\n",
    "    return Title('Image Generation Demo'), Main(H1('Magic Image Generation'), add, gen_list, cls='container')\n",
    "\n",
    "# Show the image (if available) and prompt for a generation\n",
    "def generation_preview(g):\n",
    "    grid_cls = \"box col-xs-12 col-sm-6 col-md-4 col-lg-3\"\n",
    "    image_path = f\"{g.folder}/{g.id}.png\"\n",
    "    if os.path.exists(image_path):\n",
    "        return Div(Card(\n",
    "                       Img(src=image_path, alt=\"Card image\", cls=\"card-img-top\"),\n",
    "                       Div(P(B(\"Prompt: \"), g.prompt, cls=\"card-text\"),cls=\"card-body\"),\n",
    "                   ), id=f'gen-{g.id}', cls=grid_cls)\n",
    "    return Div(f\"Generating gen {g.id} with prompt {g.prompt}\", \n",
    "            id=f'gen-{g.id}', hx_get=f\"/gens/{g.id}\", \n",
    "            hx_trigger=\"every 2s\", hx_swap=\"outerHTML\", cls=grid_cls)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a2a1820",
   "metadata": {},
   "source": [
    "You can see the final result in [main.py](https://github.com/AnswerDotAI/fasthtml-example/blob/main/image_app_simple/main.py) in the `image_app_simple` example directory, along with info on deploying it (tl;dr don't!). We've also deployed a version that only shows *your* generations (tied to browser session) and has a credit system to save our bank accounts. You can access that [here](https://image-gen-public-credit-pool.replit.app/). Now for the next question: how do we keep track of different users?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fcf3fef",
   "metadata": {},
   "source": [
    "### Again, with Sessions\n",
    "\n",
    "At the moment everyone sees all images! How do we keep some sort of unique identifier tied to a user? Before going all the way to setting up users, login pages etc., let's look at a way to at least limit generations to the user's *session*. You could do this manually with cookies. For convenience and security, fasthtml (via Starlette) has a special mechanism for storing small amounts of data in the user's browser via the `session` argument to your route. This acts like a dictionary and you can set and get values from it. For example, here we look for a `session_id` key, and if it doesn't exist we generate a new one:\n",
    "\n",
    "```python\n",
    "@app.get(\"/\")\n",
    "def get(session):\n",
    "    if 'session_id' not in session: session['session_id'] = str(uuid.uuid4())\n",
    "    return H1(f\"Session ID: {session['session_id']}\")\n",
    "```\n",
    "\n",
    "Refresh the page a few times - you'll notice that the session ID remains the same. If you clear your browsing data, you'll get a new session ID. And if you load the page in a different browser (but not a different tab), you'll get a new session ID. This will persist within the current browser, letting us use it as a key for our generations. As a bonus, someone can't spoof this session id by passing it in another way (for example, sending a query parameter). Behind the scenes, the data *is* stored in a browser cookie but it is signed with a secret key that stops the user or anyone nefarious from being able to tamper with it. The cookie is decoded back into a dictionary by something called a middleware function, which we won't cover here. All you need to know is that we can use this to store bits of state in the user's browser.\n",
    "\n",
    "In the image app example, we can add a `session_id` column to our database, and modify our homepage like so:\n",
    "```python\n",
    "@app.get(\"/\")\n",
    "def get(session):\n",
    "    if 'session_id' not in session: session['session_id'] = str(uuid.uuid4())\n",
    "    inp = Input(id=\"new-prompt\", name=\"prompt\", placeholder=\"Enter a prompt\")\n",
    "    add = Form(Group(inp, Button(\"Generate\")), hx_post=\"/\", target_id='gen-list', hx_swap=\"afterbegin\")\n",
    "    gen_containers = [generation_preview(g) for g in gens(limit=10, where=f\"session_id == '{session['session_id']}'\")]\n",
    "    ...\n",
    "```\n",
    "\n",
    "So we check if the session id exists in the session, add one if not, and then limit the generations shown to only those tied to this session id. We filter the database with a where clause - see [TODO link Jeremy's example for a more reliable way to do this]. The only other change we need to make is to store the session id in the database when a generation is made. You can check out this version [here](https://github.com/AnswerDotAI/fasthtml-example/blob/main/image_app_session_credits/session.py). You could instead write this app without relying on a database at all - simply storing the filenames of the generated images in the session, for example. But this more general approach of linking some kind of unique session identifier to users or data in our tables is a useful general pattern for more complex examples."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a58b2ef9",
   "metadata": {},
   "source": [
    "### Again, with Credits!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b01554ed",
   "metadata": {},
   "source": [
    "\n",
    "Generating images with replicate costs money. So next let's add a pool of credits that get used up whenever anyone generates an image. To recover our lost funds, we'll also set up a payment system so that generous users can buy more credits for everyone. You could modify this to let users buy credits tied to their session ID, but at that point you risk having angry customers losing their money after wiping their browser history, and should consider setting up proper account management :)\n",
    "\n",
    "Taking payments with Stripe is intimidating but very doable. [Here's a tutorial](https://testdriven.io/blog/flask-stripe-tutorial/) that shows the general principle using Flask. As with other popular tasks in the web-dev world, ChatGPT knows a lot about Stripe - but you should exercise extra caution when writing code that handles money!\n",
    "\n",
    "For the [finished example](https://github.com/AnswerDotAI/fasthtml-example/blob/main/image_app_session_credits/main.py) we add the bare minimum:\n",
    "\n",
    "- A way to create a Stripe checkout session and redirect the user to the session URL\n",
    "- 'Success' and 'Cancel' routes to handle the result of the checkout\n",
    "- A route that listens for a webhook from Stripe to update the number of credits when a payment is made.\n",
    "\n",
    "In a typical application you'll want to keep track of which users make payments, catch other kinds of stripe events and so on. This example is more a 'this is possible, do your own research' than 'this is how you do it'. But hopefully it does illustrate the key idea: there is no magic here. Stripe (and many other technologies) relies on sending users to different routes and shuttling data back and forth in requests. And we know how to do that!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09194cc4",
   "metadata": {},
   "source": [
    "## More on Routing and Request Parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f0aa668",
   "metadata": {},
   "source": [
    "There are a number of ways information can be passed to the server. When you specify arguments to a route, FastHTML will search the request for values with the same name, and convert them to the correct type. In order, it searches\n",
    "\n",
    "- The path parameters\n",
    "- The query parameters\n",
    "- The cookies\n",
    "- The headers\n",
    "- The session\n",
    "- Form data\n",
    "\n",
    "There are also a few special arguments\n",
    "\n",
    "- `request` (or any prefix like `req`): gets the raw Starlette `Request` object\n",
    "- `session` (or any prefix like `sess`): gets the session object\n",
    "- `auth`\n",
    "- `htmx`\n",
    "- `app`\n",
    "\n",
    "In this section let's quickly look at some of these in action."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2cdeb094",
   "metadata": {},
   "outputs": [],
   "source": [
    "from fasthtml.common import *\n",
    "from starlette.testclient import TestClient\n",
    "\n",
    "app = FastHTML()\n",
    "cli = TestClient(app)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4668fd8f",
   "metadata": {},
   "source": [
    "Part of the route (path parameters):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8f1e158",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Good day to you, jph!'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@app.get('/user/{nm}')\n",
    "def _(nm:str): return f\"Good day to you, {nm}!\"\n",
    "\n",
    "cli.get('/user/jph').text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d10896b",
   "metadata": {},
   "source": [
    "Matching with a regex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bc84e39",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Getting jph.ico from /foo/'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reg_re_param(\"imgext\", \"ico|gif|jpg|jpeg|webm\")\n",
    "\n",
    "@app.get(r'/static/{path:path}/{fn}.{ext:imgext}')\n",
    "def get_img(fn:str, path:str, ext:str): return f\"Getting {fn}.{ext} from /{path}\"\n",
    "\n",
    "cli.get('/static/foo/jph.ico').text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc9070f3",
   "metadata": {},
   "source": [
    "Using an enum (try using a string that isn't in the enum):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6738ab9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alexnet\n"
     ]
    }
   ],
   "source": [
    "ModelName = str_enum('ModelName', \"alexnet\", \"resnet\", \"lenet\")\n",
    "\n",
    "@app.get(\"/models/{nm}\")\n",
    "def model(nm:ModelName): return nm\n",
    "\n",
    "print(cli.get('/models/alexnet').text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fe0692d",
   "metadata": {},
   "source": [
    "Casting to a Path:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08c11e3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo.txt\n"
     ]
    }
   ],
   "source": [
    "@app.get(\"/files/{path}\")\n",
    "def txt(path: Path): return path.with_suffix('.txt')\n",
    "\n",
    "print(cli.get('/files/foo').text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c62bc855",
   "metadata": {},
   "source": [
    "An integer with a default value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df578745",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"name\":\"Bar\"}\n"
     ]
    }
   ],
   "source": [
    "fake_db = [{\"name\": \"Foo\"}, {\"name\": \"Bar\"}]\n",
    "\n",
    "@app.get(\"/items/\")\n",
    "def read_item(idx: int = 0): return fake_db[idx]\n",
    "\n",
    "print(cli.get('/items/?idx=1').text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86f92cf8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"name\":\"Foo\"}\n"
     ]
    }
   ],
   "source": [
    "# Equivalent to `/items/?idx=0`.\n",
    "print(cli.get('/items/').text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81b8e8c",
   "metadata": {},
   "source": [
    "Boolean values (takes anything \"truthy\" or \"falsy\"):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bccd0ef2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coming\n"
     ]
    }
   ],
   "source": [
    "@app.get(\"/booly/\")\n",
    "def booly(coming:bool=True): return 'Coming' if coming else 'Not coming'\n",
    "\n",
    "print(cli.get('/booly/?coming=true').text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0789b990",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not coming\n"
     ]
    }
   ],
   "source": [
    "print(cli.get('/booly/?coming=no').text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f491344",
   "metadata": {},
   "source": [
    "Getting dates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44af7ad6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-05-17 14:00:00\n"
     ]
    }
   ],
   "source": [
    "@app.get(\"/datie/\")\n",
    "def datie(d:parsed_date): return d\n",
    "\n",
    "date_str = \"17th of May, 2024, 2p\"\n",
    "print(cli.get(f'/datie/?d={date_str}').text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75b21a96",
   "metadata": {},
   "source": [
    "Matching a dataclass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1edd786e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{\"a\":1,\"b\":\"foo\",\"nm\":\"me\"}'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from dataclasses import dataclass, asdict\n",
    "\n",
    "@dataclass\n",
    "class Bodie:\n",
    "    a:int;b:str\n",
    "\n",
    "@app.route(\"/bodie/{nm}\")\n",
    "def post(nm:str, data:Bodie):\n",
    "    res = asdict(data)\n",
    "    res['nm'] = nm\n",
    "    return res\n",
    "\n",
    "cli.post('/bodie/me', data=dict(a=1, b='foo')).text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5f8fad0",
   "metadata": {},
   "source": [
    "### Cookies \n",
    "\n",
    "Cookies can be set via a Starlette Response object, and can be read back by specifying the name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "355a4a66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Set to 2024-07-20 23:14:54.364793'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "@app.get(\"/setcookie\")\n",
    "def setc(req):\n",
    "    now = datetime.now()\n",
    "    res = Response(f'Set to {now}')\n",
    "    res.set_cookie('now', str(now))\n",
    "    return res\n",
    "\n",
    "cli.get('/setcookie').text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f88438ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cookie was set at time 23:14:54.364793'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@app.get(\"/getcookie\")\n",
    "def getc(now:parsed_date): return f'Cookie was set at time {now.time()}'\n",
    "\n",
    "cli.get('/getcookie').text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea622745",
   "metadata": {},
   "source": [
    "### User Agent and HX-Request\n",
    "\n",
    "An argument of `user_agent` will match the header `User-Agent`. This holds for special headers like `HX-Request` (used by HTMX to signal when a request comes from an HTMX request) - the general pattern is that \"-\" is replaced with \"_\" and strings are turned to lowercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "724360b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'FastHTML'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@app.get(\"/ua\")\n",
    "async def ua(user_agent:str): return user_agent\n",
    "\n",
    "cli.get('/ua', headers={'User-Agent':'FastHTML'}).text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "605cbd40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@app.get(\"/hxtest\")\n",
    "def hxtest(htmx): return htmx.request\n",
    "\n",
    "cli.get('/hxtest', headers={'HX-Request':'1'}).text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c81e116",
   "metadata": {},
   "source": [
    "### Starlette Requests\n",
    "\n",
    "If you add an argument called `request`(or any prefix of that, for example `req`) it will be populated with the Starlette `Request` object. This is useful if you want to do your own processing manually. For example, although FastHTML will parse forms for you, you could instead get form data like so:\n",
    "\n",
    "```python\n",
    "@app.get(\"/form\")\n",
    "async def form(request:Request):\n",
    "    form_data = await request.form()\n",
    "    a = form_data.get('a')\n",
    "```\n",
    "\n",
    "See the [Starlette docs](https://starlette.io/docs/) for more information on the `Request` object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97eabe6d",
   "metadata": {},
   "source": [
    "### Starlette Responses\n",
    "\n",
    "You can return a Starlette Response object from a route to control the response. For example:\n",
    "\n",
    "```python\n",
    "@app.get(\"/redirect\")\n",
    "def redirect():\n",
    "    return RedirectResponse(url=\"/\")\n",
    "```\n",
    "\n",
    "We used this to set cookies in the previous example. See the [Starlette docs](https://starlette.io/docs/) for more information on the `Response` object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eed2ab70",
   "metadata": {},
   "source": [
    "### Static Files\n",
    "\n",
    "We often want to serve static files like images. This is easily done! For common file types (images, CSS etc) we can create a route that returns a Starlette `FileResponse` like so:\n",
    "\n",
    "```python\n",
    "# For images, CSS, etc.\n",
    "@app.get(\"/{fname:path}.{ext:static}\")\n",
    "def static(fname: str, ext: str):\n",
    "  return FileResponse(f'{fname}.{ext}')\n",
    "```\n",
    "\n",
    "You can customize it to suit your needs (for example, only serving files in a certain directory). You'll notice some variant of this route in all our complete examples - even for apps with no static files the browser will typically request a `/favicon.ico` file, for example, and as the astute among you will have noticed this has sparked a bit of competition between Johno and Jeremy regarding which country flag should serve as the default!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3255bce2",
   "metadata": {},
   "source": [
    "### WebSockets\n",
    "For certain applications such as multiplayer games, websockets can be a powerful feature. Luckily HTMX and FastHTML has you covered! Simply specify that you wish to include the websocket header extension from HTMX:\n",
    "\n",
    "```python\n",
    "app = FastHTML(exts='ws')\n",
    "rt = app.route\n",
    "```\n",
    "With that, you are now able to specify the different websocket specific HTMX goodies. For example, say we have a website we want to setup a websocket, you can simply:\n",
    "\n",
    "```python\n",
    "def mk_inp(): return Input(id='msg')\n",
    "\n",
    "@rt('/')\n",
    "async def get(request):\n",
    "    cts = Div(\n",
    "        Div(id='notifications'),\n",
    "        Form(mk_inp(), id='form', ws_send=True),\n",
    "        hx_ext='ws', ws_connect='/ws')\n",
    "    return Titled('Websocket Test', cts)\n",
    "```\n",
    "And this will setup a connection on the route `/ws` along with a form that will send a message to the websocket whenever the form is submitted. Let's go ahead and handle this route:\n",
    "\n",
    "```python\n",
    "@app.ws('/ws')\n",
    "async def ws(msg:str, send):\n",
    "    await send(Div('Hello ' + msg, id=\"notifications\"))\n",
    "    await sleep(2)\n",
    "    return Div('Goodbye ' + msg, id=\"notifications\"), mk_inp()\n",
    "```\n",
    "\n",
    "One thing you might have noticed is a lack of target id for our websocket trigger for swapping HTML content. This is because HTMX always swaps content with websockets with Out of Band Swaps. Therefore, HTMX will look for the id in the returned HTML content from the server for determining what to swap. To send stuff to the client, you can either use the `send` parameter or simply return the content or both!\n",
    "\n",
    "Now, sometimes you might want to perform actions when a client connects or disconnects such as add or remove a user from a player queue. To hook into these events, you can pass your connection or disconnection function to the `app.ws` decorator:\n",
    "\n",
    "```python\n",
    "async def on_connect(send):\n",
    "    print('Connected!')\n",
    "    await send(Div('Hello, you have connected', id=\"notifications\"))\n",
    "\n",
    "async def on_disconnect(ws):\n",
    "    print('Disconnected!')\n",
    "\n",
    "@app.ws('/ws', conn=on_connect, disconn=on_disconnect)\n",
    "async def ws(msg:str, send):\n",
    "    await send(Div('Hello ' + msg, id=\"notifications\"))\n",
    "    await sleep(2)\n",
    "    return Div('Goodbye ' + msg, id=\"notifications\"), mk_inp()\n",
    "````"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ec76399",
   "metadata": {},
   "source": [
    "## Full Example #3 - Chatbot Example with DaisyUI Components"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51377318",
   "metadata": {},
   "source": [
    "Let's go back to the topic of adding components or styling beyond the simple PicoCSS examples so far. How might we adopt a component or framework? In this example, let's build a chatbot UI leveraging the [DaisyUI chat bubble](https://daisyui.com/components/chat/). The final result will look like this:"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "2d4dd32c",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd1ad1eb",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "At first glance, DaisyUI's chat component looks quite intimidating. The examples look like this:\n",
    "\n",
    "```html\n",
    "<div class=\"chat chat-start\">\n",
    "  <div class=\"chat-image avatar\">\n",
    "    <div class=\"w-10 rounded-full\">\n",
    "      <img alt=\"Tailwind CSS chat bubble component\" src=\"https://img.daisyui.com/images/stock/photo-1534528741775-53994a69daeb.jpg\" />\n",
    "    </div>\n",
    "  </div>\n",
    "  <div class=\"chat-header\">\n",
    "    Obi-Wan Kenobi\n",
    "    <time class=\"text-xs opacity-50\">12:45</time>\n",
    "  </div>\n",
    "  <div class=\"chat-bubble\">You were the Chosen One!</div>\n",
    "  <div class=\"chat-footer opacity-50\">\n",
    "    Delivered\n",
    "  </div>\n",
    "</div>\n",
    "<div class=\"chat chat-end\">\n",
    "  <div class=\"chat-image avatar\">\n",
    "    <div class=\"w-10 rounded-full\">\n",
    "      <img alt=\"Tailwind CSS chat bubble component\" src=\"https://img.daisyui.com/images/stock/photo-1534528741775-53994a69daeb.jpg\" />\n",
    "    </div>\n",
    "  </div>\n",
    "  <div class=\"chat-header\">\n",
    "    Anakin\n",
    "    <time class=\"text-xs opacity-50\">12:46</time>\n",
    "  </div>\n",
    "  <div class=\"chat-bubble\">I hate you!</div>\n",
    "  <div class=\"chat-footer opacity-50\">\n",
    "    Seen at 12:46\n",
    "  </div>\n",
    "</div>\n",
    "```\n",
    "\n",
    "We have several things going for us however.\n",
    "\n",
    "- ChatGPT knows DaisyUI and Tailwind (DaisyUI is a Tailwind component library)\n",
    "- We can build things up piece by piece with AI standing by to help. \n",
    "\n",
    "[https://h2f.answer.ai/](https://h2f.answer.ai/) is a tool that can convert HTML to FT (fastcore.xml) and back, which is useful for getting a quick starting point when you have an HTML example to start from.\n",
    "\n",
    "We can strip out some unnecessary bits and try to get the simplest possible example working in a notebook first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6153a25",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading tailwind and daisyui\n",
    "headers = (Script(src=\"https://cdn.tailwindcss.com\"),\n",
    "           Link(rel=\"stylesheet\", href=\"https://cdn.jsdelivr.net/npm/daisyui@4.11.1/dist/full.min.css\"))\n",
    "\n",
    "# Displaying a single message\n",
    "d = Div(\n",
    "    Div(\"Chat header here\", cls=\"chat-header\"),\n",
    "    Div(\"My message goes here\", cls=\"chat-bubble chat-bubble-primary\"),\n",
    "    cls=\"chat chat-start\"\n",
    ")\n",
    "# show(Html(*headers, d)) # uncomment to view"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b3b874b",
   "metadata": {},
   "source": [
    "Now we can extend this to render multiple messages, with the message being on the left (`chat-start`) or right (`chat-end`) depending on the role. While we're at it, we can also change the color (`chat-bubble-primary`) of the message and put them all in a `chat-box` div:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f031581",
   "metadata": {},
   "outputs": [],
   "source": [
    "messages = [\n",
    "    {\"role\":\"user\", \"content\":\"Hello\"},\n",
    "    {\"role\":\"assistant\", \"content\":\"Hi, how can I assist you?\"}\n",
    "]\n",
    "\n",
    "def ChatMessage(msg):\n",
    "    return Div(\n",
    "        Div(msg['role'], cls=\"chat-header\"),\n",
    "        Div(msg['content'], cls=f\"chat-bubble chat-bubble-{'primary' if msg['role'] == 'user' else 'secondary'}\"),\n",
    "        cls=f\"chat chat-{'end' if msg['role'] == 'user' else 'start'}\")\n",
    "\n",
    "chatbox = Div(*[ChatMessage(msg) for msg in messages], cls=\"chat-box\", id=\"chatlist\")\n",
    "\n",
    "# show(Html(*headers, chatbox)) # Uncomment to view"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc79bdd5",
   "metadata": {},
   "source": [
    "Next, it was back to the ChatGPT to tweak the chat box so it wouldn't grow as messages were added. I asked:\n",
    "\n",
    "```\n",
    "\"I have something like this (it's working now) \n",
    "[code]\n",
    "The messages are added to this div so it grows over time. \n",
    "Is there a way I can set it's height to always be 80% of the total window height with a scroll bar if needed?\"\n",
    "```\n",
    "\n",
    "Based on this query GPT4o helpfully shared that \"This can be achieved using Tailwind CSS utility classes. Specifically, you can use h-[80vh] to set the height to 80% of the viewport height, and overflow-y-auto to add a vertical scroll bar when needed.\"\n",
    "\n",
    "To put it another way: none of the CSS classes in the following example were written by a human, and what edits I did make were informed by advice from the AI that made it relatively painless!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c45a81b",
   "metadata": {},
   "source": [
    "The actual chat functionality of the app is based on our [claudette](https://claudette.answer.ai/) library. As with the image example, we face a potential hiccup in that getting a response from an LLM is slow. We need a way to have the user message added to the UI immediately, and then have the response added once it's available. We could do something similar to the image generation example above, or use websockets. Check out the [full example](https://github.com/AnswerDotAI/fasthtml-example/tree/main/02_chatbot) for implementations of both, along with further details."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52d3ffa7",
   "metadata": {},
   "source": [
    "## Full Example #4 - Multiplayer Game of Life Example with Websockets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "822391d4",
   "metadata": {},
   "source": [
    "Let's see how we can implement a collaborative website using Websockets in FastHTML. To showcase this, we will use the famous [Conway's Game of Life](https://en.wikipedia.org/wiki/Conway's_Game_of_Life), which is a game that takes place in a grid world. Each cell in the grid can be either alive or dead. The cell's state is initially given by a user before the game is started and then evolves through the iteration of the grid world once the clock starts. Whether a cell's state will change from the previous state depends on simple rules based on its neighboring cells' states. Here is the standard Game of Life logic implemented in Python courtesy of ChatGPT:\n",
    "\n",
    "```python\n",
    "grid = [[0 for _ in range(20)] for _ in range(20)]\n",
    "def update_grid(grid: list[list[int]]) -> list[list[int]]:\n",
    "    new_grid = [[0 for _ in range(20)] for _ in range(20)]\n",
    "    def count_neighbors(x, y):\n",
    "        directions = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]\n",
    "        count = 0\n",
    "        for dx, dy in directions:\n",
    "            nx, ny = x + dx, y + dy\n",
    "            if 0 <= nx < len(grid) and 0 <= ny < len(grid[0]): count += grid[nx][ny]\n",
    "        return count\n",
    "    for i in range(len(grid)):\n",
    "        for j in range(len(grid[0])):\n",
    "            neighbors = count_neighbors(i, j)\n",
    "            if grid[i][j] == 1:\n",
    "                if neighbors < 2 or neighbors > 3: new_grid[i][j] = 0\n",
    "                else: new_grid[i][j] = 1\n",
    "            elif neighbors == 3: new_grid[i][j] = 1\n",
    "    return new_grid\n",
    "```\n",
    "\n",
    "This would be a very dull game if we were to run it, since the initial state of everything would remain dead. Therefore, we need a way of letting the user give an initial state before starting the game. FastHTML to the rescue!\n",
    "\n",
    "```python\n",
    "def Grid():\n",
    "    cells = []\n",
    "    for y, row in enumerate(game_state['grid']):\n",
    "        for x, cell in enumerate(row):\n",
    "            cell_class = 'alive' if cell else 'dead'\n",
    "            cell = Div(cls=f'cell {cell_class}', hx_put='/update', hx_vals={'x': x, 'y': y}, hx_swap='none', hx_target='#gol', hx_trigger='click')\n",
    "            cells.append(cell)\n",
    "    return Div(*cells, id='grid')\n",
    "\n",
    "@rt('/update')\n",
    "async def put(x: int, y: int):\n",
    "    grid[y][x] = 1 if grid[y][x] == 0 else 0\n",
    "```\n",
    "\n",
    "Above is a component for representing the game's state that the user can interact with and update on the server using cool HTMX features such as `hx_vals` for determining which cell was clicked to make it dead or alive. Now, you probably noticed that the HTTP request in this case is a PUT request, which does not return anything and this means our client's view of the grid world and the server's game state will immediately become out of sync :(. We could of course just return a new Grid component with the updated state, but that would only work for a single client, if we had more, they quickly get out of sync with each other and the server. Now Websockets to the rescue!\n",
    "\n",
    "Websockets are a way for the server to keep a persistent connection with clients and send data to the client without explicitly being requested for information, which is not possible with HTTP. Luckily FastHTML and HTMX work well with Websockets. Simply state you wish to use websockets for your app and define a websocket route:\n",
    "\n",
    "```python\n",
    "...\n",
    "app = FastHTML(hdrs=(picolink, gridlink, css, htmx_ws), exts='ws')\n",
    "\n",
    "player_queue = []\n",
    "async def update_players():\n",
    "    for i, player in enumerate(player_queue):\n",
    "        try: await player(Grid())\n",
    "        except: player_queue.pop(i)\n",
    "async def on_connect(send): player_queue.append(send)\n",
    "async def on_disconnect(send): await update_players()\n",
    "\n",
    "@app.ws('/gol', conn=on_connect, disconn=on_disconnect)\n",
    "async def ws(msg:str, send): pass\n",
    "\n",
    "def Home(): return Title('Game of Life'), Main(gol, Div(Grid(), id='gol', cls='row center-xs'), hx_ext=\"ws\", ws_connect=\"/gol\")\n",
    "\n",
    "@rt('/update')\n",
    "async def put(x: int, y: int):\n",
    "    grid[y][x] = 1 if grid[y][x] == 0 else 0\n",
    "    await update_players()\n",
    "...\n",
    "```\n",
    "\n",
    "Here we simply keep track of all the players that have connected or disconnected to our site and when an update occurs, we send updates to all the players still connected via websockets. Via HTMX, you are still simply exchanging HTML from the server to the client and will swap in the content based on how you setup your `hx_swap` attribute. There is only one difference, that being all swaps are OOB. You can find more information on the HTMX websocket extension documentation page [here](https://github.com/bigskysoftware/htmx-extensions/blob/main/src/ws/README.md). You can find a full fledge hosted example of this app [here](https://game-of-life-production-ed7f.up.railway.app/)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "965825d2",
   "metadata": {},
   "source": [
    "## FT objects and HTML"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fba69878",
   "metadata": {},
   "source": [
    "These FT objects create a 'FastTag' structure [tag,children,attrs] for `to_xml()`. When we call `Div(...)`, the elements we pass in are the children. Attributes are passed in as keywords. `class` and `for` are special words in python, so we use `cls`, `klass` or `_class` instead of `class` and `fr` or `_for` instead of `for`. Note these objects are just 3-element lists - you can create custom ones too as long as they're also 3-element lists. Alternately, leaf nodes can be strings instead (which is why you can do `Div('some text')`). If you pass something that isn't a 3-element list or a string, it will be converted to a string using str()... unless (our final trick) you define a `__ft__` method that will run before str(), so you can render things a custom way.\n",
    "\n",
    "For example, here's one way we could make a custom class that can be rendered into HTML:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ef6d848",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<div class=\"container\">\n",
      "  <div>Jonathan is 28 years old.</div>\n",
      "more text\n",
      "</div>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def __ft__(self):\n",
    "        return Div(f'{self.name} is {self.age} years old.')\n",
    "\n",
    "p = Person('Jonathan', 28)\n",
    "print(to_xml(Div(p, \"more text\", cls=\"container\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0eb872a",
   "metadata": {},
   "source": [
    "In the examples, you'll see we often patch in `__ft__` methods to existing classes to control how they're rendered. For example, if Person didn't have a `__ft__` method or we wanted to override it, we could add a new one like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1932ffe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "Person info:\n",
       "  <ul>\n",
       "    <li>\n",
       "Name:\n",
       "Jonathan\n",
       "    </li>\n",
       "    <li>\n",
       "Age:\n",
       "28\n",
       "    </li>\n",
       "  </ul>\n",
       "</div>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from fastcore.all import patch\n",
    "\n",
    "@patch\n",
    "def __ft__(self:Person):\n",
    "    return Div(\"Person info:\", Ul(Li(\"Name:\",self.name), Li(\"Age:\", self.age)))\n",
    "\n",
    "show(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b710ba5c",
   "metadata": {},
   "source": [
    "Some tags from fastcore.xml are overwritten by fasthtml.core and a few are further extended by fasthtml.xtend using this method. Over time, we hope to see others developing custom components too, giving us a larger and larger ecosystem of reusable components."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30e739f4",
   "metadata": {},
   "source": [
    "## Custom Scripts and Styling"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83c55dff",
   "metadata": {},
   "source": [
    "There are many popular JavaScript and CSS libraries that can be used via a simple `Script` or `Style` tag. But in some cases you will need to write more custom code. FastHTML's [js.py](https://github.com/AnswerDotAI/fasthtml/blob/main/fasthtml/js.py) contains a few examples that may be useful as reference."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c128c1e2",
   "metadata": {},
   "source": [
    "For example, to use the [marked.js](https://marked.js.org/) library to render markdown in a div, including in components added after the page has loaded via htmx, we do something like this:\n",
    "\n",
    "```javascript\n",
    "import { marked } from \"https://cdn.jsdelivr.net/npm/marked/lib/marked.esm.js\";\n",
    "proc_htmx('%s', e => e.innerHTML = marked.parse(e.textContent));\n",
    "```\n",
    "\n",
    "`proc_htmx` is a shortcut that we wrote to apply a function to elements matching a selector, including the element that triggered the event. Here's the code for reference:\n",
    "\n",
    "```javascript\n",
    "export function proc_htmx(sel, func) {\n",
    "  htmx.onLoad(elt => {\n",
    "    const elements = htmx.findAll(elt, sel);\n",
    "    if (elt.matches(sel)) elements.unshift(elt)\n",
    "    elements.forEach(func);\n",
    "  });\n",
    "}\n",
    "```\n",
    "\n",
    "The [AI Pictionary example](https://github.com/AnswerDotAI/fasthtml-example/tree/main/03_pictionary) uses a larger chunk of custom JavaScript to handle the drawing canvas. It's a good example of the type of application where running code on the client side makes the most sense, but still shows how you can integrate it with FastHTML on the server side to add functionality (like the AI responses) easily.\n",
    "\n",
    "Adding styling with custom CSS and libraries such as tailwind is done the same way we add custom JavaScript. The [doodle example](https://github.com/AnswerDotAI/fasthtml-example/tree/main/doodle) uses [Doodle.CSS](https://github.com/chr15m/DoodleCSS) to style the page in a quirky way."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c747f35",
   "metadata": {},
   "source": [
    "\n",
    "## Deploying Your App\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a97b4cc",
   "metadata": {},
   "source": [
    "We can deploy FastHTML almost anywhere you can deploy python apps. We've tested  Railway, Replit, [HuggingFace](https://github.com/AnswerDotAI/fasthtml-hf), and [PythonAnywhere](https://github.com/AnswerDotAI/fasthtml-example/blob/main/deploying-to-pythonanywhere.md).\n",
    "\n",
    "### Railway\n",
    "\n",
    "1. [Install the Railway CLI](https://docs.railway.app/guides/cli) and sign up for an account.\n",
    "2. Set up a folder with our app as `main.py`\n",
    "3. In the folder, run `railway login`.\n",
    "4. Use the `fh_railway_deploy` script to deploy our project:\n",
    "\n",
    "```bash\n",
    "fh_railway_deploy MY_APP_NAME\n",
    "```\n",
    "\n",
    "What the script does for us:\n",
    "\n",
    "4. Do we have an existing railway project?\n",
    "    - Yes: Link the project folder to our existing Railway project.\n",
    "    - No: Create a new Railway project.\n",
    "5. Deploy the project. We'll see the logs as the service is built and run!\n",
    "6. Fetches and displays the URL of our app.\n",
    "7. By default, mounts a `/app/data` folder on the cloud to our app's root folder. The app is run in `/app` by default, so from our app anything we store in `/data` will persist across restarts.\n",
    "\n",
    "A final note about Railway: We can add secrets like API keys that can be accessed as environment variables from our apps via ['Variables'](https://docs.railway.app/guides/variables). For example, for the [image generation app](https://github.com/AnswerDotAI/fasthtml-example/tree/main/image_app_simple), we can add a `REPLICATE_API_KEY` variable, and then in `main.py` we can access it as `os.environ['REPLICATE_API_KEY']`.\n",
    "\n",
    "\n",
    "\n",
    "### Replit\n",
    "\n",
    "Fork [this repl](https://replit.com/@johnowhitaker/FastHTML-Example) for a minimal example you can edit to your heart's content. `.replit` has been edited to add the right run command (`run = [\"uvicorn\", \"main:app\", \"--reload\"]`) and to set up the ports correctly. FastHTML was installed with `poetry add python-fasthtml`, you can add additional packages as needed in the same way. Running the app in Replit will show you a webview, but you may need to open in a new tab for all features (such as cookies) to work. When you're ready, you can deploy your app by clicking the 'Deploy' button. You pay for usage - for an app that is mostly idle the cost is usually a few cents per month.\n",
    "\n",
    "You can store secrets like API keys via the 'Secrets' tab in the Replit project settings.\n",
    "\n",
    "### HuggingFace\n",
    "\n",
    "Follow the instructions in [this repository](https://github.com/AnswerDotAI/fasthtml-hf) to deploy to HuggingFace spaces."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4be49ab9",
   "metadata": {},
   "source": [
    "## Where Next?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "021025fc",
   "metadata": {},
   "source": [
    "We've covered a lot of ground here! Hopefully this has given you plenty to work with in building your own FastHTML apps. If you have any questions, feel free to ask in the #fasthtml Discord channel (in the fastai Discord community). You can look through the other examples in the [fasthtml-example repository](https://github.com/AnswerDotAI/fasthtml-example) for more ideas, and keep an eye on Jeremy's [YouTube channel](https://www.youtube.com/@howardjeremyp) where we'll be releasing a number of \"dev chats\" related to FastHTML in the near future."
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 5
}
